//泛型类
class MyArray<T> {
    //泛型数组
    public Object[] array = new Object[10];

    //get(获得泛型)方法
    public T getArray(int pos) {
        return (T)array[pos];
    }
    //set(创建泛型)方法
    public void setArray(int pos ,T val) {
        array[pos] = val;
    }
}

/**
 * 实现一个泛型类求最大值
 */
class Alg1<T extends Comparable<T>> {
    public T findMax(T[] array) {
        T max = array[0];
        for(int i = 0;i < array.length;i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

class Alg2 {//泛型方法
    public<T extends Comparable<T>> T findMax(T[] array) {
        T max = array[0];
        for(int i = 0;i < array.length;i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}

class Alg3 {//泛型静态方法 可以不用实例化泛型类
    public static <T extends Comparable<T>> T findMax(T[] array) {
        T max = array[0];
        for(int i = 0;i < array.length;i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {

    }
    public static void main4(String[] args) {
        Integer[] array = {11,33,44,22};
        System.out.println(Alg3.findMax(array));
        System.out.println(Alg3.<Integer>findMax(array));
    }
    public static void main3(String[] args) {
        //泛型方法
        Alg2 alg2 = new Alg2();//实例化泛型方法
        Integer[] array = {11,33,44,22};
        System.out.println(alg2.<Integer>findMax(array));//加Integer 可以不用推导数组类型
        System.out.println(alg2.findMax(array));//不加Integer 根据传入的array数组推导类型
    }
    public static void main2(String[] args) {
        Integer[] array = {11,33,44,22};
        Alg1<Integer> alg1 = new Alg1<>();
        System.out.println(alg1.findMax(array));
    }
    public static void main1(String[] args) {
        MyArray<String> myArray1 = new MyArray<>();//实例化泛型类
        MyArray<Integer> myArray2 = new MyArray<>();
        //泛型的上界 <类型形参 extends 类型边界> 实例化<>中类型必须是类型边界的子类或者类型边界本身，不能是其他类型边界

    }
}
